// utils/yamlLoader.js
import yaml from 'js-yaml'

import { httpAction, getAction } from '@/api/manage'
// 基础API URL配置
const API_BASE_URL = '' // 使用相对路径，或者配置为你的API基础URL

/**
 * 从接口获取YAML内容
 * @param {string} fileUrl - 文件URL
 * @returns {Promise<string>} YAML内容字符串
 */
async function fetchYamlContentFromAPI(fileUrl) {
  try {
    console.log('通过API接口获取YAML内容，文件路径:', fileUrl)

    // 调用 /sys/common/getFileContent 接口
    const res = await getAction('/sys/common/getFileContent', { filePath: fileUrl })

    console.log('接口返回数据:', res)

    if (res.success && res.result) {
      console.log('从API成功获取YAML内容')
      return res.result
    } else {
      throw new Error(`API返回数据格式错误: ${res.message || '未知错误'}`)
    }
  } catch (error) {
    console.error('从API获取YAML内容失败:', error)
    throw new Error(`获取配置文件失败: ${error.message}`)
  }
}
/**
 * 从YAML文件URL加载完整的YAML内容
 * @param {string} fileUrl - YAML文件URL、本地File对象或本地文件路径
 * @returns {Promise<Object>} 完整的YAML对象
 */
export async function loadYamlParameters(fileUrl) {
  try {
    console.log('开始加载YAML文件:', fileUrl)

    // 统一通过API接口获取YAML内容
    const yamlContent = await fetchYamlContentFromAPI(fileUrl)
    console.log('YAML文件内容:', yamlContent)

    return parseYamlContent(yamlContent)
  } catch (error) {
    console.error('加载和解析YAML文件失败:', error)
    throw new Error(`加载配置文件失败: ${error.message}`)
  }
}

/**
 * 从YAML文件URL加载完整的YAML内容
 * @param {string} fileUrl - YAML文件URL、本地File对象或本地文件路径
 * @returns {Promise<Object>} 完整的YAML对象
 */
export async function loadFullYaml(fileUrl) {
  try {
    console.log('开始加载完整YAML文件:', fileUrl)

    // 统一通过API接口获取YAML内容
    const yamlContent = await fetchYamlContentFromAPI(fileUrl)
    const parsedData = yaml.load(yamlContent)

    console.log('完整YAML内容加载完成')
    return {
      content: yamlContent,
      data: parsedData,
      fileName: fileUrl.split('/').pop() || 'config.yml' // 从文件路径提取文件名
    }
  } catch (error) {
    console.error('加载完整YAML文件失败:', error)
    throw new Error(`加载配置文件失败: ${error.message}`)
  }
}
/**
 * 从YAML文件URL获取测试用例描述
 * @param {string} yamlFileUrl - YAML文件URL、本地File对象或本地文件路径
 * @returns {Promise<string>} 测试用例描述
 */
export async function getTestCaseDescription(yamlFileUrl) {
  try {
    console.log('开始获取测试用例描述:', yamlFileUrl)

    // 统一通过API接口获取YAML内容
    const yamlContent = await fetchYamlContentFromAPI(yamlFileUrl)
    const parsedData = yaml.load(yamlContent)

    // 提取测试用例描述
    const description = parsedData.TestCaseDescription || ''
    console.log('获取到的测试用例描述:', description)

    return description
  } catch (error) {
    console.error('获取测试用例描述失败:', error)
    return '无法加载用例描述: ' + error.message
  }
}

/**
 * 解析YAML内容
 * @param {string} yamlContent - YAML内容字符串
 * @returns {Object} 解析后的参数对象
 */
function parseYamlContent(yamlContent) {
  const parsedData = yaml.load(yamlContent)

  if (!parsedData || !parsedData.Parameters) {
    console.warn('YAML文件中未找到Parameters配置')
    return {}
  }

  // 提取参数配置和值
  const parametersWithValues = {}
  Object.keys(parsedData.Parameters).forEach(paramName => {
    const paramConfig = parsedData.Parameters[paramName]
    parametersWithValues[paramName] = {
      ...paramConfig,
      // 确保包含当前值
      Value: paramConfig.Value !== undefined ? paramConfig.Value : null
    }
  })

  console.log('解析后的参数:', parametersWithValues)
  return parametersWithValues
}

/**
 * 直接解析YAML内容字符串
 * @param {string} yamlContent - YAML内容字符串
 * @returns {Object} 解析后的参数对象
 */
export function parseYamlParameters(yamlContent) {
  try {
    return parseYamlContent(yamlContent)
  } catch (error) {
    console.error('解析YAML内容失败:', error)
    throw new Error(`解析配置文件失败: ${error.message}`)
  }
}

/**
 * 更新YAML数据中的值
 * @param {Object} yamlData - YAML数据对象
 * @param {Object} formValues - 表单值对象
 * @returns {Object} 更新后的YAML数据
 */
export function updateYamlValues(yamlData, formValues) {
  const updatedData = JSON.parse(JSON.stringify(yamlData))

  if (updatedData.Parameters) {
    Object.keys(formValues).forEach(key => {
      if (updatedData.Parameters[key]) {
        updatedData.Parameters[key].Value = formValues[key]
      }
    })
  }

  return updatedData
}

/**
 * 将数据对象转换为YAML字符串
 * @param {Object} data - 数据对象
 * @returns {string} YAML字符串
 */
export function convertToYamlString(data) {
  return yaml.dump(data, {
    indent: 2,
    lineWidth: -1 // 不限制行宽
  })
}

/**
 * 创建YAML文件的Blob对象
 * @param {string} yamlContent - YAML内容
 * @param {string} fileName - 文件名
 * @returns {Blob} Blob对象
 */
export function createYamlBlob(yamlContent, fileName) {
  return new Blob([yamlContent], {
    type: 'application/x-yaml'
  })
}

/**
 * 上传YAML文件到服务器
 * @param {Blob} yamlBlob - YAML文件的Blob对象
 * @param {string} fileName - 文件名
 * @param {Object} params - 额外参数
 * @returns {Promise<Object>} 上传结果
 */
export async function uploadYamlFile(yamlBlob, fileName, params = {}) {
  const formData = new FormData()
  formData.append('file', yamlBlob, fileName)

  // 添加额外参数
  Object.keys(params).forEach(key => {
    formData.append(key, params[key])
  })

  try {
    const response = await fetch('/api/upload', {
      method: 'POST',
      body: formData
    })

    if (!response.ok) {
      throw new Error(`上传失败! 状态码: ${response.status}`)
    }

    const result = await response.json()
    return result
  } catch (error) {
    console.error('上传YAML文件失败:', error)
    throw new Error(`上传文件失败: ${error.message}`)
  }
}

/**
 * 生成表单验证规则
 * @param {Object} parameters - 参数配置对象
 * @returns {Object} 验证规则对象
 */
export function generateValidationRules(parameters) {
  const rules = {}

  Object.keys(parameters).forEach(paramName => {
    const paramConfig = parameters[paramName]
    const paramRules = []

    // 必填规则
    if (paramConfig.required !== false) {
      paramRules.push({
        required: true,
        message: `请输入${paramConfig.Description}`
      })
    }

    // 类型特定验证
    if (paramConfig.Type === 'int') {
      paramRules.push({
        validator: (rule, value, callback) => {
          if (value === undefined || value === null || value === '') {
            callback('请输入有效的数值')
            return
          }

          // 验证是否为整数
          const numValue = Number(value)
          if (!Number.isInteger(numValue)) {
            callback('请输入整数')
            return
          }

          // 验证范围
          if (paramConfig.Range) {
            const [min, max] = paramConfig.Range
            if (numValue < min || numValue > max) {
              callback(`数值必须在 ${min} 到 ${max} 之间`)
              return
            }
          }

          callback()
        }
      })
    }

    rules[paramName] = paramRules
  })

  return rules
}

/**
 * 生成表单占位符文本
 * @param {Object} parameters - 参数配置对象
 * @returns {Object} 占位符对象
 */
export function generatePlaceholders(parameters) {
  const placeholders = {}

  Object.keys(parameters).forEach(paramName => {
    const paramConfig = parameters[paramName]

    if (paramConfig.Type === 'int' && paramConfig.Range) {
      placeholders[paramName] = `请输入 ${paramConfig.Range[0]} - ${paramConfig.Range[1]} 之间的整数值`
    } else {
      placeholders[paramName] = `请输入${paramConfig.Description}`
    }
  })

  return placeholders
}

/**
 * 下载YAML文件
 * @param {string} yamlContent - YAML内容
 * @param {string} fileName - 文件名
 */
export function downloadYamlFile(yamlContent, fileName = 'config.yml') {
  const blob = createYamlBlob(yamlContent, fileName)
  const url = URL.createObjectURL(blob)
  const link = document.createElement('a')
  link.href = url
  link.download = fileName
  document.body.appendChild(link)
  link.click()
  document.body.removeChild(link)
  URL.revokeObjectURL(url)
}

/**
 * 格式化描述信息
 * @param {string} description - 原始描述
 * @returns {string} 格式化后的描述
 */
export function formatDescription(description) {
  if (!description || typeof description !== 'string') {
    return '无描述信息'
  }

  try {
    var lines = description.split('\n')
    var info = {}

    // 定义要提取的字段映射
    var fieldMappings = [
      { key: 'name', prefix: '测试用例名称:' },
      { key: 'purpose', prefix: '测试目的:' },
      { key: 'id', prefix: '测试用例ID:' },
      { key: 'precondition', prefix: '前置条件:' }
    ]

    // 遍历每一行提取信息
    lines.forEach(function(line) {
      var trimmedLine = line.trim()

      fieldMappings.forEach(function(mapping) {
        if (trimmedLine.indexOf(mapping.prefix) !== -1) {
          var parts = trimmedLine.split(mapping.prefix)
          if (parts.length > 1 && parts[1].trim()) {
            info[mapping.key] = parts[1].trim()
          }
        }
      })
    })

    // 定义显示顺序和标签
    var displayFields = [
      { key: 'name', label: '用例' },
      { key: 'id', label: 'ID' },
      { key: 'purpose', label: '目的' },
      { key: 'precondition', label: '前置' }
    ]

    // 构建格式化字符串
    var formattedParts = []
    displayFields.forEach(function(field) {
      if (info[field.key]) {
        formattedParts.push(field.label + ': ' + info[field.key])
      }
    })

    var formatted = formattedParts.join('\n')

    // 如果没有提取到任何信息，返回截断版本
    if (!formatted) {
      var truncated = description.replace(/\n/g, ' ').substring(0, 100)
      if (description.length > 100) {
        truncated += '...'
      }
      return truncated
    }

    return formatted
  } catch (error) {
    console.error('格式化描述失败:', error)
    var truncated = description.replace(/\n/g, ' ').substring(0, 50)
    if (description.length > 50) {
      truncated += '...'
    }
    return truncated
  }
}
